Crate actix_web_opentelemetry

OpenTelemetry integration for Actix Web.

This crate allows you to easily instrument client and server requests.

• Server requests can be traced by using the RequestTracing middleware.

The awc feature allows you to instrument client requests made by the awc crate.

• Client requests can be traced by using the ClientExt::trace_request method.

The metrics feature allows you to expose request metrics to Prometheus.

• Metrics can be tracked using the RequestMetrics middleware.

Client Request Examples:

Note: this requires the awc feature to be enabled.

use awc::{Client, error::SendRequestError};
use actix_web_opentelemetry::ClientExt;

async fn execute_request(client: &Client) -> Result<(), SendRequestError> {
    let res = client
        .get("http://localhost:8080")
        // Add `trace_request` before `send` to any awc request to add instrumentation
        .trace_request()
        .send()
        .await?;

    println!("Response: {:?}", res);
    Ok(())
}

Server middleware examples:

Tracing and metrics middleware can be used together or independently.

Tracing server example:

use actix_web::{web, App, HttpServer};
use actix_web_opentelemetry::RequestTracing;

async fn index() -> &'static str {
    "Hello world!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // Install an OpenTelemetry trace pipeline.
    // Swap for https://docs.rs/opentelemetry-jaeger or other compatible
    // exporter to send trace information to your collector.
    opentelemetry::sdk::export::trace::stdout::new_pipeline().install_simple();

    HttpServer::new(|| {
        App::new()
            .wrap(RequestTracing::new())
            .service(web::resource("/").to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Request metrics middleware (requires the metrics feature):

use actix_web::{dev, http, web, App, HttpRequest, HttpServer};
use actix_web_opentelemetry::RequestMetrics;
use opentelemetry::global;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let exporter = opentelemetry_prometheus::exporter().init();
    let meter = global::meter("actix_web");

    // Optional predicate to determine which requests render the prometheus metrics
    let metrics_route = |req: &dev::ServiceRequest| {
        req.path() == "/metrics" && req.method() == http::Method::GET
    };

    // Request metrics middleware
    let request_metrics = RequestMetrics::new(meter, Some(metrics_route), Some(exporter));

    // Run actix server, metrics are now available at http://localhost:8080/metrics
    HttpServer::new(move || App::new().wrap(request_metrics.clone()))
        .bind("localhost:8080")?
        .run()
        .await
}

Exporter configuration

actix-web uses tokio as the underlying executor, so exporters should be configured to be non-blocking:

[dependencies]
opentelemetry-jaeger = { version = "..", features = ["rt-tokio-current-thread"] }

opentelemetry-zipkin = { version = "..", features = ["reqwest-client"], default-features = false }

Structs

InstrumentedClientRequest

A wrapper for the actix-web awc::ClientRequest.

RequestMetrics

Request metrics tracking

RequestMetricsMiddleware

Request metrics middleware

RequestTracing

Request tracing middleware.

Traits

ClientExt

OpenTelemetry extensions for actix-web’s awc::Client.

RouteFormatter

Interface for formatting routes from paths.